10 मिनट में C सीखें
C एक शक्तिशाली, सामान्य-उद्देश्य प्रोग्रामिंग भाषा है जो अपनी दक्षता और हार्डवेयर के करीब क्षमताओं के लिए जानी जाती है। यह ट्यूटोरियल C प्रोग्रामिंग के मूल सिद्धांतों को कवर करता है, जो आपको भाषा को जल्दी से समझने में मदद करेगा।
1. अपना पहला C प्रोग्राम लिखना
आइए क्लासिक “Hello, World!” प्रोग्राम से शुरू करते हैं। hello.c
नाम की एक फ़ाइल बनाएं और निम्नलिखित कोड दर्ज करें:
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
फ़ाइल को सेव करें और GCC जैसे C कंपाइलर का उपयोग करके इसे कंपाइल करें:
gcc hello.c -o hello
./hello
आउटपुट होगा:
Hello, World!
यह सरल प्रोग्राम C की बुनियादी संरचना प्रदर्शित करता है:
#include <stdio.h>
स्टैंडर्ड इनपुट/आउटपुट लाइब्रेरी शामिल करता हैint main()
प्रोग्राम का एंट्री पॉइंट हैprintf()
टेक्स्ट आउटपुट प्रदर्शित करता हैreturn 0
सफल निष्पादन को इंगित करता है
2. बेसिक सिंटैक्स
C स्टेटमेंट्स को समाप्त करने के लिए सेमीकोलन और कोड ब्लॉक्स को परिभाषित करने के लिए कर्ली ब्रेसिज {}
के साथ एक संरचित सिंटैक्स का उपयोग करता है।
// यह एक सिंगल-लाइन कमेंट है
/* यह एक मल्टी-लाइन कमेंट है */
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
C में बेसिक सिंटैक्स नियम:
- सेमीकोलन: हर स्टेटमेंट सेमीकोलन
;
के साथ समाप्त होना चाहिए - कमेंट्स: सिंगल-लाइन कमेंट्स
//
का उपयोग करते हैं, मल्टी-लाइन कमेंट्स/* */
का उपयोग करते हैं - कोड ब्लॉक्स: कर्ली ब्रेसिज
{}
द्वारा परिभाषित - केस सेंसिटिविटी: C केस-सेंसिटिव है (
main
बनामMain
)
3. वेरिएबल्स और डेटा टाइप्स
C एक स्टैटिकली टाइप्ड भाषा है, जिसका अर्थ है कि आपको उपयोग से पहले वेरिएबल टाइप्स घोषित करने होंगे।
बेसिक वेरिएबल नेमिंग नियम:
- वेरिएबल नामों में अक्षर, संख्याएं और अंडरस्कोर हो सकते हैं
- वेरिएबल नाम संख्या से शुरू नहीं हो सकते
- वेरिएबल नाम केस-सेंसिटिव होते हैं
- C कीवर्ड्स का उपयोग वेरिएबल नामों के रूप में नहीं किया जा सकता
C के मुख्य डेटा टाइप्स:
- int: पूर्णांक संख्याएं (जैसे,
42
,-10
) - float: फ्लोटिंग-पॉइंट संख्याएं (जैसे,
3.14
,-2.5
) - double: डबल-प्रिसिजन फ्लोटिंग-पॉइंट संख्याएं
- char: सिंगल करैक्टर्स (जैसे,
'A'
,'z'
) - void: कोई टाइप नहीं
int age = 25;
float temperature = 36.5;
double pi = 3.14159265359;
char grade = 'A';
3.1 इंटीजर टाइप्स
C विभिन्न आकारों के साथ कई इंटीजर टाइप्स प्रदान करता है:
char small_number = 100; // आमतौर पर 1 बाइट
short medium_number = 32000; // आमतौर पर 2 बाइट्स
int regular_number = 1000000; // आमतौर पर 4 बाइट्स
long large_number = 1000000000; // आमतौर पर 4 या 8 बाइट्स
3.2 फ्लोटिंग-पॉइंट टाइप्स
float single_precision = 3.14f;
double double_precision = 3.14159265359;
long double extended_precision = 3.14159265358979323846L;
3.3 करैक्टर टाइप
करैक्टर्स ASCII एन्कोडिंग का उपयोग करके इंटीजर्स के रूप में संग्रहीत होते हैं:
char letter = 'A';
char digit = '7';
char newline = '\n';
char tab = '\t';
4. कॉन्स्टेंट्स
कॉन्स्टेंट्स फिक्स्ड वैल्यूज होती हैं जिन्हें प्रोग्राम निष्पादन के दौरान बदला नहीं जा सकता:
const int MAX_SIZE = 100;
const float PI = 3.14159;
const char NEWLINE = '\n';
#define MAX_USERS 1000
#define PI 3.14159
5. इनपुट और आउटपुट
C इनपुट और आउटपुट ऑपरेशन्स के लिए stdio.h
से फंक्शन्स का उपयोग करता है।
5.1 printf() के साथ आउटपुट
#include <stdio.h>
int main() {
int age = 25;
float height = 1.75;
char name[] = "John";
printf("Hello, %s!\n", name);
printf("You are %d years old\n", age);
printf("Your height is %.2f meters\n", height);
return 0;
}
कॉमन फॉर्मेट स्पेसिफायर्स:
%d
- इंटीजर%f
- फ्लोट/डबल%c
- करैक्टर%s
- स्ट्रिंग%p
- पॉइंटर
5.2 scanf() के साथ इनपुट
#include <stdio.h>
int main() {
int age;
float height;
char name[50];
printf("Enter your name: ");
scanf("%s", name);
printf("Enter your age: ");
scanf("%d", &age);
printf("Enter your height: ");
scanf("%f", &height);
printf("Hello %s, you are %d years old and %.2f meters tall\n",
name, age, height);
return 0;
}
6. ऑपरेटर्स
C विभिन्न कंप्यूटेशन्स के लिए ऑपरेटर्स का एक समृद्ध सेट प्रदान करता है।
6.1 अरिथमेटिक ऑपरेटर्स
int a = 10, b = 3;
printf("Addition: %d\n", a + b); // 13
printf("Subtraction: %d\n", a - b); // 7
printf("Multiplication: %d\n", a * b); // 30
printf("Division: %d\n", a / b); // 3
printf("Modulus: %d\n", a % b); // 1
6.2 कम्पेरिजन ऑपरेटर्स
int x = 5, y = 10;
printf("Equal: %d\n", x == y); // 0 (false)
printf("Not equal: %d\n", x != y); // 1 (true)
printf("Greater than: %d\n", x > y); // 0
printf("Less than: %d\n", x < y); // 1
6.3 लॉजिकल ऑपरेटर्स
int a = 1, b = 0;
printf("AND: %d\n", a && b); // 0
printf("OR: %d\n", a || b); // 1
printf("NOT: %d\n", !a); // 0
6.4 बिटवाइज ऑपरेटर्स
unsigned int a = 5; // बाइनरी में 0101
unsigned int b = 3; // बाइनरी में 0011
printf("AND: %d\n", a & b); // 1 (0001)
printf("OR: %d\n", a | b); // 7 (0111)
printf("XOR: %d\n", a ^ b); // 6 (0110)
printf("NOT: %d\n", ~a); // सिस्टम पर निर्भर करता है
printf("Left shift: %d\n", a << 1); // 10 (1010)
printf("Right shift: %d\n", a >> 1); // 2 (0010)
7. कंट्रोल फ्लो
C प्रोग्राम निष्पादन को प्रबंधित करने के लिए कई कंट्रोल फ्लो स्टेटमेंट्स प्रदान करता है।
7.1 if स्टेटमेंट्स
int age = 20;
if (age >= 18) {
printf("Adult\n");
} else if (age >= 13) {
printf("Teen\n");
} else {
printf("Child\n");
}
7.2 switch स्टेटमेंट्स
int day = 3;
switch (day) {
case 1:
printf("Monday\n");
break;
case 2:
printf("Tuesday\n");
break;
case 3:
printf("Wednesday\n");
break;
default:
printf("Other day\n");
}
7.3 for लूप्स
for (int i = 0; i < 5; i++) {
printf("i = %d\n", i);
}
7.4 while लूप्स
int count = 0;
while (count < 5) {
printf("Count: %d\n", count);
count++;
}
7.5 do-while लूप्स
int count = 0;
do {
printf("Count: %d\n", count);
count++;
} while (count < 5);
7.6 break और continue
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // लूप से बाहर निकलें
}
if (i % 2 == 0) {
continue; // इवन नंबर्स को स्किप करें
}
printf("i = %d\n", i); // आउटपुट: 1, 3
}
8. ऐरेज़
ऐरेज़ एक ही टाइप के कई वैल्यूज को स्टोर करते हैं।
8.1 वन-डायमेंशनल ऐरेज़
int numbers[5] = {1, 2, 3, 4, 5};
// एलिमेंट्स तक पहुंचना
printf("First element: %d\n", numbers[0]);
printf("Last element: %d\n", numbers[4]);
// एलिमेंट्स को मॉडिफाई करना
numbers[0] = 10;
// ऐरे के माध्यम से लूपिंग
for (int i = 0; i < 5; i++) {
printf("numbers[%d] = %d\n", i, numbers[i]);
}
8.2 मल्टी-डायमेंशनल ऐरेज़
int matrix[2][3] = {
{1, 2, 3},
{4, 5, 6}
};
// एलिमेंट्स तक पहुंचना
printf("matrix[1][2] = %d\n", matrix[1][2]); // 6
// 2D ऐरे के माध्यम से लूपिंग
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
9. स्ट्रिंग्स
C में, स्ट्रिंग्स करैक्टर्स के ऐरे होते हैं जो एक नल करैक्टर \0
द्वारा समाप्त होते हैं।
char greeting[] = "Hello"; // ऑटोमैटिकली नल टर्मिनेटर शामिल करता है
char name[20] = "John";
// string.h से स्ट्रिंग फंक्शन्स
#include <string.h>
char str1[20] = "Hello";
char str2[20] = "World";
printf("Length: %lu\n", strlen(str1)); // 5
strcpy(str1, str2); // str2 को str1 में कॉपी करें
printf("After copy: %s\n", str1); // World
if (strcmp(str1, str2) == 0) {
printf("Strings are equal\n");
}
10. फंक्शन्स
फंक्शन्स पुन: प्रयोज्य कोड ब्लॉक्स होते हैं जो विशिष्ट कार्य करते हैं।
10.1 फंक्शन डेफिनिशन और कॉलिंग
#include <stdio.h>
// फंक्शन डिक्लेरेशन
int add(int a, int b);
int main() {
int result = add(5, 3);
printf("5 + 3 = %d\n", result);
return 0;
}
// फंक्शन डेफिनिशन
int add(int a, int b) {
return a + b;
}
10.2 नो रिटर्न वैल्यू वाले फंक्शन
void greet(char name[]) {
printf("Hello, %s!\n", name);
}
int main() {
greet("Alice");
return 0;
}
10.3 रिकर्सिव फंक्शन्स
int factorial(int n) {
if (n <= 1) {
return 1;
}
return n * factorial(n - 1);
}
int main() {
printf("5! = %d\n", factorial(5)); // 120
return 0;
}
11. पॉइंटर्स
पॉइंटर्स वेरिएबल्स होते हैं जो मेमोरी एड्रेस स्टोर करते हैं।
11.1 बेसिक पॉइंटर यूज़ेज
int number = 42;
int *ptr = &number; // ptr number का एड्रेस स्टोर करता है
printf("Value: %d\n", number); // 42
printf("Address: %p\n", &number); // मेमोरी एड्रेस
printf("Pointer value: %d\n", *ptr); // 42 (डेरिफरेंसिंग)
// पॉइंटर के माध्यम से वैल्यू मॉडिफाई करना
*ptr = 100;
printf("New value: %d\n", number); // 100
11.2 पॉइंटर्स और ऐरेज़
int numbers[] = {1, 2, 3, 4, 5};
int *ptr = numbers; // पहले एलिमेंट को पॉइंट करता है
printf("First element: %d\n", *ptr); // 1
printf("Second element: %d\n", *(ptr + 1)); // 2
// ऐरे नाम अनिवार्य रूप से पहले एलिमेंट का पॉइंटर है
for (int i = 0; i < 5; i++) {
printf("numbers[%d] = %d\n", i, *(numbers + i));
}
11.3 पॉइंटर्स और फंक्शन्स
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main() {
int x = 5, y = 10;
printf("Before swap: x=%d, y=%d\n", x, y);
swap(&x, &y);
printf("After swap: x=%d, y=%d\n", x, y);
return 0;
}
12. स्ट्रक्चर्स
स्ट्रक्चर्स आपको संबंधित वेरिएबल्स को एक साथ समूहित करने की अनुमति देते हैं।
12.1 स्ट्रक्चर्स को डिफाइन और यूज़ करना
#include <stdio.h>
#include <string.h>
// स्ट्रक्चर डेफिनिशन
struct Student {
char name[50];
int age;
float gpa;
};
int main() {
// स्ट्रक्चर वेरिएबल्स बनाना
struct Student student1;
// वैल्यूज असाइन करना
strcpy(student1.name, "Alice");
student1.age = 20;
student1.gpa = 3.8;
// स्ट्रक्चर मेंबर्स तक पहुंचना
printf("Name: %s\n", student1.name);
printf("Age: %d\n", student1.age);
printf("GPA: %.2f\n", student1.gpa);
return 0;
}
12.2 पॉइंटर्स के साथ स्ट्रक्चर
struct Point {
int x;
int y;
};
int main() {
struct Point p1 = {10, 20};
struct Point *ptr = &p1;
printf("Coordinates: (%d, %d)\n", ptr->x, ptr->y);
return 0;
}
13. डायनामिक मेमोरी एलोकेशन
C डायनामिक मेमोरी मैनेजमेंट के लिए फंक्शन्स प्रदान करता है।
13.1 malloc, calloc, realloc, free
#include <stdio.h>
#include <stdlib.h>
int main() {
// 5 इंटीजर्स के लिए मेमोरी एलोकेट करें
int *numbers = (int*)malloc(5 * sizeof(int));
if (numbers == NULL) {
printf("Memory allocation failed!\n");
return 1;
}
// ऐरे इनिशियलाइज़ करें
for (int i = 0; i < 5; i++) {
numbers[i] = i * 10;
}
// ऐरे प्रिंट करें
for (int i = 0; i < 5; i++) {
printf("numbers[%d] = %d\n", i, numbers[i]);
}
// एलोकेटेड मेमोरी फ्री करें
free(numbers);
return 0;
}
13.2 डायनामिक स्ट्रिंग एलोकेशन
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
char *name = (char*)malloc(50 * sizeof(char));
if (name != NULL) {
strcpy(name, "Dynamic string");
printf("Name: %s\n", name);
free(name);
}
return 0;
}
14. फाइल ऑपरेशन्स
C फाइलों से पढ़ने और फाइलों में लिखने के लिए फंक्शन्स प्रदान करता है।
14.1 फाइल में लिखना
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "w");
if (file == NULL) {
printf("Error opening file!\n");
return 1;
}
fprintf(file, "Hello, File!\n");
fprintf(file, "This is a test.\n");
fclose(file);
printf("File written successfully.\n");
return 0;
}
14.2 फाइल से पढ़ना
#include <stdio.h>
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
printf("Error opening file!\n");
return 1;
}
char buffer[100];
while (fgets(buffer, sizeof(buffer), file) != NULL) {
printf("%s", buffer);
}
fclose(file);
return 0;
}
15. प्रीप्रोसेसर डायरेक्टिव्स
प्रीप्रोसेसर डायरेक्टिव्स कंपाइलेशन से पहले प्रोसेस किए जाते हैं।
15.1 #include
#include <stdio.h> // सिस्टम हेडर फाइल
#include "myheader.h" // यूजर हेडर फाइल
15.2 #define
#define PI 3.14159
#define MAX(a, b) ((a) > (b) ? (a) : (b))
int main() {
double area = PI * 5 * 5;
int larger = MAX(10, 20);
printf("Area: %.2f\n", area);
printf("Larger number: %d\n", larger);
return 0;
}
15.3 कंडीशनल कंपाइलेशन
#define DEBUG 1
int main() {
#ifdef DEBUG
printf("Debug mode enabled\n");
#endif
#if DEBUG == 1
printf("Debug level 1\n");
#elif DEBUG == 2
printf("Debug level 2\n");
#else
printf("No debug\n");
#endif
return 0;
}
16. एरर हैंडलिंग
C में बिल्ट-इन एक्सेप्शन हैंडलिंग नहीं है, इसलिए हम रिटर्न वैल्यूज और एरर कोड्स का उपयोग करते हैं।
#include <stdio.h>
#include <errno.h>
#include <string.h>
int main() {
FILE *file = fopen("nonexistent.txt", "r");
if (file == NULL) {
printf("Error opening file: %s\n", strerror(errno));
return 1;
}
fclose(file);
return 0;
}
यह व्यापक C ट्यूटोरियल C में प्रोग्रामिंग शुरू करने के लिए आवश्यक आवश्यक अवधारणाओं को कवर करता है। इन उदाहरणों का अभ्यास करें और जैसे-जैसे आप भाषा के साथ अधिक सहज होते जाते हैं, लिंक्ड लिस्ट्स, फंक्शन पॉइंटर्स और मल्टी-फाइल प्रोग्राम्स जैसे अधिक उन्नत विषयों का पता लगाएं।